68 research outputs found
Dynamic Integer Sets with Optimal Rank, Select, and Predecessor Search
We present a data structure representing a dynamic set S of w-bit integers on
a w-bit word RAM. With |S|=n and w > log n and space O(n), we support the
following standard operations in O(log n / log w) time:
- insert(x) sets S = S + {x}. - delete(x) sets S = S - {x}. - predecessor(x)
returns max{y in S | y= x}. -
rank(x) returns #{y in S | y< x}. - select(i) returns y in S with rank(y)=i, if
any.
Our O(log n/log w) bound is optimal for dynamic rank and select, matching a
lower bound of Fredman and Saks [STOC'89]. When the word length is large, our
time bound is also optimal for dynamic predecessor, matching a static lower
bound of Beame and Fich [STOC'99] whenever log n/log w=O(log w/loglog w).
Technically, the most interesting aspect of our data structure is that it
supports all the above operations in constant time for sets of size n=w^{O(1)}.
This resolves a main open problem of Ajtai, Komlos, and Fredman [FOCS'83].
Ajtai et al. presented such a data structure in Yao's abstract cell-probe model
with w-bit cells/words, but pointed out that the functions used could not be
implemented. As a partial solution to the problem, Fredman and Willard
[STOC'90] introduced a fusion node that could handle queries in constant time,
but used polynomial time on the updates. We call our small set data structure a
dynamic fusion node as it does both queries and updates in constant time.Comment: Presented with different formatting in Proceedings of the 55nd IEEE
Symposium on Foundations of Computer Science (FOCS), 2014, pp. 166--175. The
new version fixes a bug in one of the bounds stated for predecessor search,
pointed out to me by Djamal Belazzougu
Radix Sorting With No Extra Space
It is well known that n integers in the range [1,n^c] can be sorted in O(n)
time in the RAM model using radix sorting. More generally, integers in any
range [1,U] can be sorted in O(n sqrt{loglog n}) time. However, these
algorithms use O(n) words of extra memory. Is this necessary?
We present a simple, stable, integer sorting algorithm for words of size
O(log n), which works in O(n) time and uses only O(1) words of extra memory on
a RAM model. This is the integer sorting case most useful in practice. We
extend this result with same bounds to the case when the keys are read-only,
which is of theoretical interest. Another interesting question is the case of
arbitrary c. Here we present a black-box transformation from any RAM sorting
algorithm to a sorting algorithm which uses only O(1) extra space and has the
same running time. This settles the complexity of in-place sorting in terms of
the complexity of sorting.Comment: Full version of paper accepted to ESA 2007. (17 pages
Dynamic Connectivity: Connecting to Networks and Geometry
Dynamic connectivity is a well-studied problem, but so far the most
compelling progress has been confined to the edge-update model: maintain an
understanding of connectivity in an undirected graph, subject to edge
insertions and deletions. In this paper, we study two more challenging, yet
equally fundamental problems.
Subgraph connectivity asks to maintain an understanding of connectivity under
vertex updates: updates can turn vertices on and off, and queries refer to the
subgraph induced by "on" vertices. (For instance, this is closer to
applications in networks of routers, where node faults may occur.)
We describe a data structure supporting vertex updates in O (m^{2/3})
amortized time, where m denotes the number of edges in the graph. This greatly
improves over the previous result [Chan, STOC'02], which required fast matrix
multiplication and had an update time of O(m^0.94). The new data structure is
also simpler.
Geometric connectivity asks to maintain a dynamic set of n geometric objects,
and query connectivity in their intersection graph. (For instance, the
intersection graph of balls describes connectivity in a network of sensors with
bounded transmission radius.)
Previously, nontrivial fully dynamic results were known only for special
cases like axis-parallel line segments and rectangles. We provide similarly
improved update times, O (n^{2/3}), for these special cases. Moreover, we show
how to obtain sublinear update bounds for virtually all families of geometric
objects which allow sublinear-time range queries, such as arbitrary 2D line
segments, d-dimensional simplices, and d-dimensional balls.Comment: Full version of a paper to appear in FOCS 200
- …